home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / math / gle-3.000 / gle-3 / gle / util / manip / manip.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-07  |  16.2 KB  |  644 lines
  1. #include "all.h"
  2. #include "edt.h"
  3. #ifdef __TURBOC__
  4. #define DASHCHAR 249
  5. #include <alloc.h>
  6. #include "bios.h"
  7. #include "conio.h"
  8. #include "dir.h"
  9. #define WLEN 4
  10. #define WEND 24
  11. #elif DJ                /* a.r. */
  12. #define clrscr ScreenClear
  13. #define DASHCHAR 249
  14. #include <gppconio.h>
  15. #include <dir.h>
  16. #define WLEN 4
  17. #define WEND 24
  18. #elif EMXOS2            /* a.r. */
  19. #define DASHCHAR 249
  20. #define WLEN 4
  21. #define WEND 24
  22. #else
  23. #define WLEN 3
  24. #define WEND 23
  25. #define DASHCHAR '.'
  26. #include "vaxconio.h"
  27. #endif
  28.  
  29. #define true (!false)
  30. #define false 0
  31. #define BCOLOR BLUE
  32. #define FCOLOR MAGENTA
  33. /* function prototypes */
  34.  
  35. /*
  36. manip /com=a.a
  37.  
  38.         refresh screen.
  39.         edit cell mode,
  40.         command mode.
  41.         arrow keys scroll screen.
  42.  
  43.         data cell:range
  44.         cell:range = expression
  45.         expressions,           c,r,x,y,c1..cn,r1..rn,sum(range),
  46.                         c(x-1,y) = c(x,y)
  47.  
  48. */
  49. /* global stuff */
  50. int noscreenio;
  51. int gle_debug;
  52. int moving_x,moving_y;
  53. int data_x;
  54. int data_y;
  55. int changed;
  56. extern int islogging;
  57. extern int isating;
  58. /* local stuff */
  59. int iserr,dont_clear;
  60. int scr_frow=1,scr_fcol=1;
  61. int scr_width=76,scr_colwidth=8;
  62. int scr_ncol;
  63. int scr_nrow=18;
  64. int curx,cury;
  65. int max_x=0,max_y=0;         /* change to 1,1 */
  66.  
  67. int scr_blackwhite;
  68. int exit_manip;
  69. char file_name[80];
  70. int in_recover,single_step;
  71. char gleroot[80];
  72. extern char strmiss[];
  73. #ifdef unix
  74. #include "../../glepath.h"
  75. #elif DJ                    /* a.r. */
  76. #include "../../glepath.h"
  77. #endif
  78. /*---------------------------------------------------------------------------*/
  79. main(int argc, char **argv)
  80. {
  81.         int i;
  82.         char ans[90];
  83.         int cmd;
  84.         static char atfile[80];
  85.         char *ss;
  86.         strcpy(gleroot,argv[0]);
  87. #if ( defined DJ || EMXOS2 || defined unix )
  88.         ss = getenv("GLE_TOP");
  89.         if (ss==NULL) ss = GLEPATH;
  90.         strcpy(gleroot,ss);
  91. #endif
  92.         scr_init();
  93. #ifdef __TURBOC__
  94.         ss = strchr(gleroot,'\\');
  95.         if (ss==NULL) {fner("Unable to locat help file, press key to continue\n"); scr_getch();}
  96.         for (;strchr(ss+1,'\\')!=NULL;) ss = strchr(ss+1,'\\');
  97.         *(ss+1) = 0;
  98. #endif
  99.         if (strmiss[0]==0) strcpy(strmiss,"-");
  100.  
  101.         for (i=1;i<argc;i++) {
  102.                 strupr( argv[i] );
  103.                 if (strncmp( argv[i] , "-RECOVER",2)==0) in_recover = true;
  104.                 else if (strncmp( argv[i] , "-STEP",3)==0) single_step = true ;
  105.                 else if (strncmp( argv[i] , "-SIZE",4)==0) {
  106.                         data_setsize(atoi(argv[i+1]),atoi(argv[i+2]));
  107.                         i+=2;
  108.                 }
  109.                 else if (strncmp( argv[i] , "-COMMANDS",2)==0) strcpy(atfile,argv[++i]);
  110.                 else if (strncmp( argv[i] , "-DEBUG",2)==0)                 ;
  111.                 else if (strncmp( argv[i] , "-FLOAT",2)==0)  set_usefloat();
  112.                 else if (strncmp( argv[i] , "-SINGLE",4)==0)  set_usefloat();
  113.                 else if (isalnum(*argv[i])) strcpy(file_name, argv[i]);
  114.                 else {
  115.                         printf("Unrecognized parameter {%s} \n",argv[i]);
  116.                         printf("Usage: MANIP infile.dat -recover -step -commands c.log -single -size x y\n");
  117.                         exit(0);
  118.                 }
  119.         }
  120.         init_logging(file_name);
  121.  
  122.  
  123.         if (atfile[0]!=0) at_open(atfile);
  124.         strlwr(file_name);
  125.         if (strlen(file_name)>0) cmd_load(file_name,"",2);
  126. xx1:
  127.         if (strlen(file_name)==0) strcpy(file_name,"mtest.dat");
  128.         set_colwidth(10);
  129.         changed = false;
  130.         for (;exit_manip==false;) {
  131.                 top_line();
  132.                 hi_cell(curx,cury);
  133.                 mjl_flush();
  134.                 read_command(&cmd,ans,"% ");
  135.                 if (cmd==eescape || cmd==equit) break;
  136.                 if (cmd==0)         do_command(ans);
  137.                 else if (cmd==eload) {
  138.                         pick_file(ans,"*.dat");
  139.                         refresh();
  140.                         clear_data();
  141.                         cmd_load(ans,"",2);
  142.                 } else if (cmd==ehelp) {
  143.                         do_help("MANIP","");
  144.                         refresh();
  145.                 } else if (cmd==esave) {
  146.                         text_save();
  147.                         refresh();
  148.                 } else if (cmd==eload) {
  149.                         refresh();
  150.                 } else           do_arrow(cmd);
  151.         }
  152.         if (cmd==eescape) if (text_changed()) { exit_manip = false; goto xx1;}
  153.         window_exit();
  154.         if (islogging) log_close();
  155.         scr_end();
  156. }
  157. text_changed()
  158. {
  159.         int c;
  160.         if (!changed) return false;
  161.         for (;;) {
  162.                 fner("Save in {%s} ? (Y,N)",file_name);
  163.                 c = text_inkey();
  164.                 fner_clear();
  165.                 if (c==eescape) return true;
  166.                 if (tolower(c)=='n') return false;
  167.                 if (tolower(c)=='y') {text_save(); return false;}
  168.         }
  169. }
  170. text_save()
  171. {
  172.         cmd_save(file_name,"","",2);
  173.         changed = false;
  174. }
  175. fix_cur()
  176. {
  177.         if (curx<1) curx = 1;
  178.         if (cury<1) cury = 1;
  179. }
  180. shift_window()
  181. {
  182.         int doit=false;
  183.         fix_cur();
  184.         if (curx<scr_fcol || curx >= scr_fcol + scr_ncol) {
  185.                 scr_fcol = curx - scr_ncol/2;
  186.                 if (scr_fcol<1) scr_fcol = 1;
  187.                 doit = true;
  188.         }
  189.         if (cury<scr_frow || cury >= scr_frow + scr_nrow) {
  190.                 scr_frow = cury - scr_nrow/2;
  191.                 if (scr_frow<1) scr_frow = 1;
  192.                 doit = true;
  193.         }
  194.         if (doit) refresh();
  195. }
  196. do_arrow(int k)
  197. {
  198.         char buff[280];
  199.         show_cellwide(curx,cury);
  200.         moving_x = moving_y = 0;
  201.         switch (k) {
  202.         case eup:        cury--; moving_y = -1;  break;
  203.         case edown:     cury++; moving_y = 1; break;
  204.         case eright:        curx++; moving_x = 1; break;
  205.         case eleft:        curx--; moving_x = -1; break;
  206.         case edelline:        cury+=12; break;
  207.         case esearch:         cury-=12; break;
  208.         case ebigright: curx+=6; break;
  209.         case ebigleft:         curx-=6; break;
  210.         }
  211.         fix_cur();
  212.         sprintf(buff,"goto %d %d ",curx,cury);
  213.         if (islogging) log_write(buff);
  214.         shift_window();
  215.         hi_cell(curx,cury);
  216. }
  217. set_newxy(int x, int y)
  218. {
  219.         show_cellwide(curx,cury);
  220.         curx = x;
  221.         cury = y;
  222.         shift_window();
  223.         hi_cell(curx,cury);
  224. }
  225. window_norm()
  226. {
  227.         window(1,1,80,25);
  228. }
  229. window_exit()
  230. {
  231.         window(1,1,80,25);
  232.         gotoxy(1,25);
  233.         scr_norm();
  234.         printf("\n");clreol();
  235. }
  236. set_colwidth(int n)
  237. {
  238.         scr_colwidth = n;
  239.         scr_ncol = scr_width/scr_colwidth;
  240.         shift_window();
  241.         refresh();
  242. }
  243. set_ncol(int n)
  244. {
  245.         scr_ncol = n;
  246.         scr_colwidth = scr_width/scr_ncol;
  247.         scr_ncol;
  248.         shift_window();
  249.         refresh();
  250. }
  251. top_line()
  252. {
  253.         gotoxy(1,1); clreol();
  254.         #ifdef MANIPCURPOS /* a.r.: to see, which cell is edited, if -DNOATTRIB */
  255.         wprintf("Free=%ld  Current Cell( c = %d, r = %d ) MANIP 3.3  File={%s}"
  256.                 ,coreleft(),curx,cury,file_name);
  257.         #else
  258.         wprintf("Free=%ld  Used(%d,%d) MANIP 3.3    Current file={%s}"
  259.                 ,coreleft(),max_x,max_y,file_name);
  260.         #endif
  261. }
  262. void refresh()
  263. {
  264.         int i,j;
  265.  
  266.         fix_cur();
  267.         window_norm();
  268.         scr_norm();
  269.         clrscr();
  270.         top_line();
  271.         fner_clear();
  272.  
  273.         scr_menuhi();
  274.         for (i=1;i<=scr_ncol;i++) {
  275.                 gotocell(i+scr_fcol-1,scr_frow-1);
  276.                 wprintf("c%d",i+scr_fcol-1);
  277.         }
  278.         for (i=1;i<=scr_nrow;i++) {
  279.                 gotocell(scr_fcol-1,i+scr_frow-1);
  280.                 wprintf("r%d",i+scr_frow-1);
  281.         }
  282.         scr_norm();
  283.  
  284.         for (j=0;j<scr_nrow;j++) {
  285.          for (i=0;i<scr_ncol;i++) {
  286.                 show_cell(i+scr_fcol,j+scr_frow);
  287.          }
  288.         }
  289.         iserr = true;
  290.         fner_clear();
  291.         hi_cell(curx,cury);
  292. }
  293. hi_cell(int x,int y)
  294. {
  295.         scr_menuhi();
  296.         show_cellwide(x,y);
  297.         scr_norm();
  298. }
  299. gotocell(int x,int y)
  300. {
  301.         if (x==scr_fcol-1) gotoxy( (x-scr_fcol+1)*scr_colwidth+1,(y-scr_frow)+3);
  302.         else gotoxy( (x-scr_fcol)*scr_colwidth+6,(y-scr_frow)+3);
  303. }
  304. void show_ifcell(int x, int y)
  305. {
  306.         if (x>=scr_fcol && x<(scr_fcol+scr_ncol)) {
  307.         if (y>=scr_frow && y<(scr_frow+scr_nrow)) {
  308.                 show_cellwide(x,y);
  309.         }
  310.         }
  311. }
  312. void show_cell(int x, int y)
  313. {
  314.         gotocell(x,y);
  315.         cputs(scell(x,y));
  316. }
  317. void show_cellwide(int x, int y)
  318. {
  319.         char buff[280];
  320.         gotocell(x,y);
  321.         strcpy(buff,scell(x,y));
  322.         if (strlen(buff)<(scr_colwidth-1)) 
  323.                 ncpy(buff+strlen(buff),"                ",
  324.                         scr_colwidth-strlen(buff)-1);
  325.         cputs(buff);
  326. }
  327. #ifdef unix
  328. wprintf_do(char *s)
  329. {
  330.         printw("%s",s);
  331. }
  332. fner_do(char *output)
  333. {
  334.         if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  335.         fnerx(output);
  336. }
  337. printmess_do(char *output)
  338. {
  339.         if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  340.         fnerxx(output);
  341. }
  342. #endif
  343.  
  344. #ifndef unix
  345. void wprintf(va_list arg_list, ...)
  346. /* Prints to the window */
  347. {
  348.          va_list arg_ptr;
  349.          char *format;
  350.         char output[200];
  351.  
  352.          va_start(arg_ptr, arg_list);
  353.          format = arg_list;
  354.          vsprintf(output, format, arg_ptr);
  355. #ifdef __TURBOC__
  356.         printf(output);
  357. #else
  358.         cputs(output);
  359. #endif
  360. }
  361.  
  362. void fner(va_list arg_list, ...)
  363. /* Prints to the window */
  364. {
  365.          va_list arg_ptr;
  366.          char *format;
  367.          char output[200];
  368.  
  369.          va_start(arg_ptr, arg_list);
  370.          format = arg_list;
  371.         vsprintf(output, format, arg_ptr);
  372.         if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  373.         fnerx(output);
  374. }
  375. void printmess(va_list arg_list, ...)
  376. /* Prints to the window */
  377. {
  378.          va_list arg_ptr;
  379.          char *format;
  380.         char output[200];
  381.  
  382.          va_start(arg_ptr, arg_list);
  383.          format = arg_list;
  384.         vsprintf(output, format, arg_ptr);
  385.         if (strchr(output,'\n')!=NULL) *strchr(output,'\n') = 0;
  386.         fnerxx(output);
  387. }
  388. #endif
  389. d_tidyup()
  390. {}
  391. gle_abort(char *s)
  392. {
  393.         fner("ABORT {%s}\n",s);
  394.         exit(1);
  395. }
  396.  
  397. char *function_bar(void);
  398. void fner_clear(void)
  399. {
  400.         if (iserr==false) return;
  401.         if (dont_clear) return;
  402.         scr_savexy();
  403.         window_norm();
  404.         gotoxy(1,25);
  405.         scr_grey();
  406.         clreol();
  407.         gotoxy(2,25);
  408.         cputs(function_bar());
  409.         scr_norm();
  410.         iserr = false;
  411.         window_norm();
  412.         scr_restorexy();
  413. }
  414. fnerx(char *s)
  415. {
  416.         if (dont_clear) return;
  417.         scr_savexy();
  418.         iserr = true;
  419.         window_norm();
  420.         gotoxy(1,25);
  421.         scr_inv();
  422.         clreol();
  423.         gotoxy(2,25);
  424.         cputs(s);
  425.         scr_norm();
  426.         scr_restorexy();
  427.         scr_refresh();
  428. }
  429. fnerxx(char *s)
  430. {
  431.         scr_savexy();
  432.         command_scroll_up();
  433.         iserr = true;
  434.         window_norm();
  435.         gotoxy(1,23);
  436.         scr_inv();
  437.         clreol();
  438.         gotoxy(2,23);
  439.         cputs(s);
  440.         scr_norm();
  441.         scr_restorexy();
  442.         scr_refresh();
  443. }
  444. int read_command(int *cmd,char *ans,char *ques)
  445. {
  446.         static char *lastline[22];
  447.         int cl=0;
  448.         int rr,i;
  449.         int direc=0;
  450.  
  451.         if (isating) {
  452.                 if (!at_read(ans)) goto contxx;
  453.                 window(1,21,80,WEND);
  454.                 gotoxy(1,WLEN);
  455.                 scr_inv();
  456.                 clreol();
  457.                 gotoxy(2,WLEN);
  458.                 clreol(); *cmd = 0;
  459.                 cputs(ques); cputs(ans);  rr = false;
  460.                 goto xxend;
  461.         }
  462. contxx:;
  463.         *ans = 0;
  464.         iserr = true;
  465.         window(1,21,80,WEND);
  466.         gotoxy(1,WLEN);
  467.         scr_inv();
  468.         clreol();
  469. xxxx:  
  470.        #ifndef EMXOS2  /* cause EMX has not really a function window()  a.r. */
  471.         gotoxy(2,WLEN);
  472.        #else
  473.         gotoxy(1,24);
  474.        #endif
  475.         clreol();
  476.         cputs(ques);
  477.         rr = read_str(cmd,ans);
  478.         if (*cmd == epageup) {
  479.                 if (direc==-1) cl++;
  480.                 if (lastline[cl]!=NULL) {
  481.                         strcpy(ans,lastline[cl]);
  482.                         cl++;
  483.                 }
  484.                 if (cl>18) cl = 0;
  485.                 direc = 1;
  486.                 goto xxxx;
  487.         }
  488.         if (*cmd == epagedown) {
  489.                 if (direc==1) cl--;
  490.                 cl--;
  491.                 direc = -1;
  492.                 if (cl<0) {cl = -1; *ans = 0; goto xxxx;}
  493.                 if (lastline[cl]!=NULL) strcpy(ans,lastline[cl]);
  494.                 goto xxxx;
  495.         }
  496. xxend:
  497.         gotoxy(1,WLEN);
  498.         if (strlen(ans)>0) {
  499.                 if (lastline[20]!=NULL) free(lastline[20]);
  500.                 for (i=20;i>0;i--) lastline[i] = lastline[i-1];
  501.                 lastline[0] = sdup(ans);
  502.                 command_scroll_up();
  503.         }
  504.         scr_norm();
  505. #ifndef EMXOS2          /* a.r. */
  506.         clreol();
  507. #endif
  508.         window_norm();
  509.         return rr;
  510. }
  511. int read_str(int *cmd, char *s)
  512. {
  513.         int c,cx=0;
  514.         char mbuff[280];
  515.         *cmd = 0;
  516.         cputs(s); cx = strlen(s);
  517.         for (;;) {
  518.          c = text_inkey();
  519.          if (iserr) fner_clear();
  520.          if (strlen(s)==0) {
  521.                 switch (c) {
  522.         case edelline:
  523.         case esearch: 
  524.         case ebigright:
  525.         case ebigleft: 
  526.                   case eup:
  527.                   case edown:
  528.                   case eleft:
  529.                   case eright:
  530.                   case equit:
  531.                   case eescape:
  532.                   case eload:
  533.                   case esave:
  534.                   case ehelp:
  535.                      *cmd = c;
  536.                      return false;
  537.                 }
  538.          }
  539.          switch (c) {
  540.            case ebackline:
  541.                 c = epageup;
  542.           case eload:
  543.           case esave:
  544.           case ehelp:
  545.            case epagedown:
  546.            case epageup:
  547.                 *cmd = c;
  548.                 return false;
  549.            case eescape: /* ESCAPE */
  550.                 *cmd = c;
  551.            case equit: /* control c */
  552.                 return true;
  553.            case eleft: /* left */
  554.                 if (cx <= 0) break;
  555.                 cx--;
  556.                 scr_left(1);
  557.                 break;
  558.            case eright: /* right */
  559.                 if (cx >= strlen(s)) break;
  560.                 cx++;
  561.                 scr_right(1);
  562.                 break;
  563.         case edelline:
  564.         case esearch: 
  565.         case ebigright:
  566.         case ebigleft: 
  567.            case eup: /* arrow up */
  568.            case edown: /* arrow down */
  569.                 break;
  570.           case ereturn: /* carriage return */
  571.                 return false;
  572.           case edelete: /* delete */
  573.                 if (strlen(s)==0) break;
  574.                 if (cx<1) break;
  575.                 ncpy(mbuff,s,cx-1);
  576.                 strcat(mbuff,s + cx);
  577.                 strcpy(s,mbuff);
  578.                 cx--;
  579.                 scr_left(1);
  580.                 cputs(s + cx);
  581.                 putch(' ');
  582.                 scr_left(strlen(s+cx)+1);
  583.                 break;
  584.           case eshowerror:
  585.           case edrawit:
  586.                 break;
  587.           default: /* normal key */
  588.                 if (c<26  && c!=9) {fner("Key has no affect"); break;}
  589.                 if (c>200)  fner("Unimplemented command");
  590.                 else {
  591.                         ncpy(mbuff,s,cx);
  592.                         mbuff[cx] = c; mbuff[cx+1] = 0;
  593.                         strcat(mbuff,s + cx);
  594.                         strcpy(s,mbuff);
  595.                         cputs(s + cx);
  596.                         cx++;
  597.                         scr_left(strlen(s+cx));
  598.                 }
  599.                 break;
  600.            }
  601.          }
  602. }
  603. command_scroll_up()
  604. {
  605.         window(1,21,80,WEND);
  606.         gotoxy(1,1);
  607.         delline();
  608. }
  609. char *gle_top()
  610. {
  611.         char s[80];
  612. #ifdef unix
  613.         return gleroot;
  614. #endif
  615. #ifdef __TURBOC__
  616.         return gleroot;
  617. #elif ( defined DJ || defined EMXOS2 || defined unix)
  618.         strcpy(s,gleroot);
  619.         strcat(s, "/");
  620.         return s;
  621. #else
  622.         return "cgle_top:";
  623. #endif
  624. }
  625. char *gledir(char *s);
  626. char *gledir(char *fname)
  627. {
  628.         static char fbuff[80];
  629. #ifdef __TURBOC__
  630.         strcpy(fbuff,gle_top());
  631. #elif DJ                                /* a.r. */
  632.         strcpy(fbuff,gle_top());
  633. #elif EMXOS2                            /* a.r. */
  634.         strcpy(fbuff,gle_top());
  635. #else
  636.         strcpy(fbuff,"cgle_top:");
  637. #endif
  638. #ifdef unix
  639.         strcpy(fbuff,gle_top());
  640. #endif
  641.         strcat(fbuff,fname);
  642.         return &fbuff[0];
  643. }
  644.